Index: COLLADASaxFrameworkLoader/include/COLLADASaxFWLColladaParserAutoGenPrivate.h
===================================================================
--- COLLADASaxFrameworkLoader/include/COLLADASaxFWLColladaParserAutoGenPrivate.h	(revision 571)
+++ COLLADASaxFrameworkLoader/include/COLLADASaxFWLColladaParserAutoGenPrivate.h	(working copy)
@@ -23,8 +23,8 @@
 
 
 // you may disable validation here
-#define VALIDATION
-//#undef VALIDATION
+//#define VALIDATION
+#undef VALIDATION
 
 
 namespace COLLADASaxFWL
Index: COLLADASaxFrameworkLoader/include/COLLADASaxFWLTransformationLoader.h
===================================================================
--- COLLADASaxFrameworkLoader/include/COLLADASaxFWLTransformationLoader.h	(revision 571)
+++ COLLADASaxFrameworkLoader/include/COLLADASaxFWLTransformationLoader.h	(working copy)
@@ -12,8 +12,8 @@
 #define __COLLADASAXFWL_TRANSFORMATIONLOADER_H__
 
 #include "COLLADASaxFWLPrerequisites.h"
+#include "COLLADAFWPrerequisites.h"
 
-
 namespace COLLADAFW
 { 
 	class Transformation;
Index: COLLADASaxFrameworkLoader/src/COLLADASaxFWLLibraryControllersLoader.cpp
===================================================================
--- COLLADASaxFrameworkLoader/src/COLLADASaxFWLLibraryControllersLoader.cpp	(revision 571)
+++ COLLADASaxFrameworkLoader/src/COLLADASaxFWLLibraryControllersLoader.cpp	(working copy)
@@ -97,7 +97,7 @@
 			// Write the indices
 			if (  mCurrentOffset == mJointOffset )
 			{
-				COLLADAFW::UIntValuesArray& jointIndices = mCurrentSkinControllerData->getJointIndices();
+				COLLADAFW::IntValuesArray& jointIndices = mCurrentSkinControllerData->getJointIndices();
 				jointIndices.append ( index );
 			}
 
Index: COLLADASaxFrameworkLoader/src/COLLADASaxFWLColladaParserAutoGenPrivate.cpp
===================================================================
--- COLLADASaxFrameworkLoader/src/COLLADASaxFWLColladaParserAutoGenPrivate.cpp	(revision 571)
+++ COLLADASaxFrameworkLoader/src/COLLADASaxFWLColladaParserAutoGenPrivate.cpp	(working copy)
@@ -160,8 +160,10 @@
     }
     case HASH_ATTRIBUTE_XMLNS:
     {
+#if 0
     this->mDocumentNamespace = Utils::calculateStringHash(attributeValue);
     this->mDocUsesTargetNamespace = this->mDocumentNamespace == TARGET_NAMESPACE;
+#endif
     break;
     }
     default:
@@ -174,7 +176,9 @@
         }
         else
         {
+#if 0
             this->mNamespaces[ hashPair.second ] = Utils::calculateStringHash( attributeValue );
+#endif
         }
 
     }
@@ -182,6 +186,7 @@
     }
 }
 
+#if 0
     if ( !this->mDocUsesTargetNamespace )
     {
         if ( handleError(ParserError::SEVERITY_ERROR_NONCRITICAL, ParserError::ERROR_XML_DIFFERENT_TARGETNAMESPACE, 0, (const ParserChar*)0, "Document does not use XSD target namespace.") )
@@ -189,6 +194,7 @@
             return false;
         }
     }
+#endif
 
     return true;
 }
Index: COLLADASaxFrameworkLoader/src/COLLADASaxFWLSidAddress.cpp
===================================================================
--- COLLADASaxFrameworkLoader/src/COLLADASaxFWLSidAddress.cpp	(revision 571)
+++ COLLADASaxFrameworkLoader/src/COLLADASaxFWLSidAddress.cpp	(working copy)
@@ -19,6 +19,65 @@
 
 	const int regExpMatchesVectorLength = 30;    /* should be a multiple of 3 */
 	const char* sidSeparator = "/";
+
+	enum RegexpType {
+		REGEXP_ACCESSOR_NAME,
+		REGEXP_ACCESSOR_INDEX,
+		REGEXP_EXT,
+	};
+
+	static pcre *re_accessor_name = NULL;
+	static pcre *re_accessor_index = NULL;
+
+	static void dumpCompiledRegexp(const char *filename, pcre *re)
+	{
+		int rc;
+		size_t length;
+		rc = pcre_fullinfo(re,               /* result of pcre_compile() */
+						   NULL,             /* result of pcre_study(), or NULL */
+						   PCRE_INFO_SIZE,   /* what is required */
+						   &length);         /* where to put the data */
+		FILE *file = fopen(filename, "wb");
+		char *byte = (char*)re;
+		fprintf(file, "char regex[%d] = {\n", length);
+		for (int i = 0; i < length; i++, byte++) {
+			fprintf(file, "%d,", (int)*byte);
+		}
+		fprintf(file, "\n};");
+		// fwrite((void*) re, length, 1, file);
+		fclose(file);
+	}
+
+	static void compileRegexps()
+	{
+		const char* error;
+		int erroffset;
+		re_accessor_name = pcre_compile("(.+)\\.(.+)", 0, &error, &erroffset, NULL);
+		if (!re_accessor_name)
+			fprintf(stderr, "Error compiling accessor name regex: %s\n", error);
+
+		re_accessor_index = pcre_compile("([^(]+)(?:\\(([0-9]+)\\))?(?:\\(([0-9]+)\\))?", 0, &error, &erroffset, NULL);
+		if (!re_accessor_index)
+			fprintf(stderr, "Error compiling accessor index regex: %s\n", error);
+
+		// dumpCompiledRegexp("/tmp/compiledRegexText.c", re_accessor_name);
+	}
+
+	static pcre* getCompiledRegexp(RegexpType type)
+	{
+		if (!re_accessor_name)
+			compileRegexps();
+
+		switch(type) {
+		case REGEXP_ACCESSOR_NAME:
+			return re_accessor_name;
+		case REGEXP_ACCESSOR_INDEX:
+			return re_accessor_index;
+		}
+		
+		return NULL;
+	}
+
 
 	//------------------------------
 	SidAddress::SidAddress( const String& sidAddress )
@@ -102,8 +161,9 @@
 
 
 		// regular expression: "(.+)\.(.+)"
-		static const char _accessorNameRegex[69]={69,82,67,80,69,0,0,0,0,0,0,0,5,0,0,0,2,0,0,0,0,0,46,2,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,25,95,0,7,0,1,59,12,85,0,7,28,46,95,0,7,0,2,59,12,85,0,7,85,0,25,0,};
-		pcre* accessorNameRegex = (pcre*) _accessorNameRegex;
+		// static const char _accessorNameRegex[69]={69,82,67,80,69,0,0,0,0,0,0,0,5,0,0,0,2,0,0,0,0,0,46,2,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,25,95,0,7,0,1,59,12,85,0,7,28,46,95,0,7,0,2,59,12,85,0,7,85,0,25,0,};
+		// pcre* accessorNameRegex = (pcre*) _accessorNameRegex;
+		pcre *accessorNameRegex = getCompiledRegexp(REGEXP_ACCESSOR_NAME);
 
 		int accessorNameMatches[regExpMatchesVectorLength];
 
@@ -156,8 +216,9 @@
 		else 
 		{
 			// regular expression: "([^(]+)(?:\(([0-9]+)\))?(?:\(([0-9]+)\))?"
-			char _accessorIndexRegex[163]={69,82,67,80,-93,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,119,95,0,7,0,1,46,40,85,0,7,103,94,0,49,28,40,95,0,39,0,2,78,0,0,0,0,0,0,-1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,72,85,0,39,28,41,85,0,49,103,94,0,49,28,40,95,0,39,0,3,78,0,0,0,0,0,0,-1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,72,85,0,39,28,41,85,0,49,85,0,119,0,};
-			pcre* accessorIndexRegex = (pcre*) _accessorIndexRegex;
+			// char _accessorIndexRegex[163]={69,82,67,80,-93,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,119,95,0,7,0,1,46,40,85,0,7,103,94,0,49,28,40,95,0,39,0,2,78,0,0,0,0,0,0,-1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,72,85,0,39,28,41,85,0,49,103,94,0,49,28,40,95,0,39,0,3,78,0,0,0,0,0,0,-1,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,72,85,0,39,28,41,85,0,49,85,0,119,0,};
+			// pcre* accessorIndexRegex = (pcre*) _accessorIndexRegex;
+			pcre *accessorIndexRegex = (pcre*) getCompiledRegexp(REGEXP_ACCESSOR_INDEX);
 
 			int accessorIndexMatches[regExpMatchesVectorLength];
 
Index: GeneratedSaxParser/include/GeneratedSaxParserRawUnknownElementHandler.h
===================================================================
--- GeneratedSaxParser/include/GeneratedSaxParserRawUnknownElementHandler.h	(revision 571)
+++ GeneratedSaxParser/include/GeneratedSaxParserRawUnknownElementHandler.h	(working copy)
@@ -64,7 +64,7 @@
 		/** Disable default assignment operator. */
 		const RawUnknownElementHandler& operator= ( const RawUnknownElementHandler& pre );
 	
-		void RawUnknownElementHandler::prepareToAddContents();
+		void prepareToAddContents();
 	};
 } // namespace GENERATEDSAXPARSER
 
Index: GeneratedSaxParser/include/GeneratedSaxParserUtils.h
===================================================================
--- GeneratedSaxParser/include/GeneratedSaxParserUtils.h	(revision 571)
+++ GeneratedSaxParser/include/GeneratedSaxParserUtils.h	(working copy)
@@ -38,7 +38,7 @@
 
 		static StringHash calculateStringHash(const ParserChar* text);
 
-        static StringHashPair Utils::calculateStringHashWithNamespace( const ParserChar* text );
+        static StringHashPair calculateStringHashWithNamespace( const ParserChar* text );
 
         static StringHash calculateStringHash(const ParserChar* text, bool& failed);
 
Index: COLLADAStreamWriter/src/COLLADASWInstanceMaterial.cpp
===================================================================
--- COLLADAStreamWriter/src/COLLADASWInstanceMaterial.cpp	(revision 571)
+++ COLLADAStreamWriter/src/COLLADASWInstanceMaterial.cpp	(working copy)
@@ -41,7 +41,7 @@
 	//---------------------------------------------------------------
 	void BindVertexInput::add( StreamWriter* sw )
 	{
-		sw->openElement ( CSWC::CSW_ELEMENT_INSTANCE_MATERIAL );
+		sw->openElement ( CSWC::CSW_ELEMENT_BIND_VERTEX_INPUT );
 		sw->appendAttribute ( CSWC::CSW_ATTRIBUTE_SEMANTIC, getSemantic() );
 		sw->appendAttribute ( CSWC::CSW_ATTRIBUTE_INPUT_SEMANTIC, getInputSemantic() );
 		sw->appendAttribute ( CSWC::CSW_ATTRIBUTE_INPUT_SET, getInputSet() );
Index: COLLADABaseUtils/src/COLLADABUURI.cpp
===================================================================
--- COLLADABaseUtils/src/COLLADABUURI.cpp	(revision 571)
+++ COLLADABaseUtils/src/COLLADABUURI.cpp	(working copy)
@@ -26,8 +26,70 @@
 	const String URI::SCHEME_HTTP = "http";
 	const String URI::SCHEME_HTTPS = "https";
 
+	// compiled on runtime but only once 
+	static pcre *re_matchURI = NULL;
+	static pcre *re_findDir = NULL;
+	static pcre *re_findExt = NULL;
 
+	enum RegexpType {
+		REGEXP_URI,
+		REGEXP_DIR,
+		REGEXP_EXT,
+	};
 
+	static void dumpCompiledRegexp(const char *filename, pcre *re)
+	{
+		int rc;
+		size_t length;
+		rc = pcre_fullinfo(re,               /* result of pcre_compile() */
+						   NULL,             /* result of pcre_study(), or NULL */
+						   PCRE_INFO_SIZE,   /* what is required */
+						   &length);         /* where to put the data */
+		FILE *fout = fopen(filename, "wb");
+// 		for (int i = 0; i < length; i++) {
+// 			fprintf(fout, "%c,", ((char *)re)[i]);
+// 		}
+		fwrite((void*) re, length, 1, fout);
+		fclose(fout);
+	}
+
+	static void compileRegexps()
+	{
+		const char* error;
+		int erroffset;
+		re_matchURI = pcre_compile("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?",
+								0, &error, &erroffset, NULL);
+		if (!re_matchURI)
+			fprintf(stderr, "Error compiling re_matchURI: %s\n", error);
+
+		// dumpCompiledRegexp("/tmp/compiledRegexText.c", re_matchURI);
+
+		re_findDir = pcre_compile("(.*/)?(.*)?", 0, &error, &erroffset, NULL);
+		if (!re_findDir)
+			fprintf(stderr, "Error compiling re_findDir: %s\n", error);
+
+		re_findExt = pcre_compile("([^.]*)?(\\.(.*))?", 0, &error, &erroffset, NULL);
+		if (!re_findExt)
+			fprintf(stderr, "Error compiling re_findExt: %s\n", error);
+	}
+
+	static pcre* getCompiledRegexp(RegexpType type)
+	{
+		if (!re_matchURI)
+			compileRegexps();
+
+		switch(type) {
+		case REGEXP_URI:
+			return re_matchURI;
+		case REGEXP_DIR:
+			return re_findDir;
+		case REGEXP_EXT:
+			return re_findExt;
+		}
+		
+		return NULL;
+	}
+
 	const char HEX2DEC[256] = 
 	{
 		/*       0  1  2  3   4  5  6  7   8  9  A  B   C  D  E  F */
@@ -266,15 +328,13 @@
 			// /tmp/se.3/file
 
 			// regular expression: "(.*/)?(.*)?"
-			static const char _findDir[71]={69,82,67,80,71,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,27,103,95,0,9,0,1,57,12,28,47,
-				85,0,9,103,95,0,7,0,2,57,12,85,0,7,85,0,27,0,};
-			pcre* findDir = (pcre*) _findDir;
+			// static const char _findDir[71]={69,82,67,80,71,0,0,0,0,0,0,0,1,0,0,0,2,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,27,103,95,0,9,0,1,57,12,28,47,85,0,9,103,95,0,7,0,2,57,12,85,0,7,85,0,27,0,};
+			pcre* findDir = getCompiledRegexp(REGEXP_DIR);
 
 
 			// regular expression: "([^.]*)?(\.(.*))?"
-			static const char _findExt[79]={69,82,67,80,79,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,35,103,95,0,7,0,1,44,46,85,0,7
-				,103,95,0,17,0,2,28,46,95,0,7,0,3,57,12,85,0,7,85,0,17,85,0,35,0,};
-			pcre* findExt = (pcre*) _findExt;
+			// static const char _findExt[79]={69,82,67,80,79,0,0,0,0,0,0,0,1,0,0,0,3,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,35,103,95,0,7,0,1,44,46,85,0,7,103,95,0,17,0,2,28,46,95,0,7,0,3,57,12,85,0,7,85,0,17,85,0,35,0,};
+			pcre* findExt = getCompiledRegexp(REGEXP_EXT);
 			
 			String tmpFile;
 			dir.clear();
@@ -473,7 +533,7 @@
 	namespace {
 		void normalize(String& path) {
 			URI::normalizeURIPath(const_cast<char*>(path.c_str()));
-			path = path.substr(0, strlen(path.c_str()));
+			path = path.substr(0, path.size());
 		}
 	}
 
@@ -882,8 +942,8 @@
 		// This regular expression for parsing URI references comes from the URI spec:
 		//   http://tools.ietf.org/html/rfc3986#appendix-B
 		// regular expression: "^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?"
-		static const char _matchUri[240]={69,82,67,80,-16,0,0,0,16,0,0,0,1,0,0,0,9,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,-60,26,103,95,0,49,0,1,95, 0,39,0,2,79,-1,-1,-1,-1,-9,127,-1,123,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,72,85,0,39,28,58,85,0,49,103,95,0,51,0,3,28,47,28,47,95,0,39,0,4,79,-1,-1,-1,-1,-9,127,-1,127,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,70,85,0,39,85,0,51,95,0,39,0,5,79,-1,-1,-1,-1,-9,-1,-1,127,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,70,85,0,39,103,95,0,17,0,6,28,63,95,0,7,0,7,44,35,85,0,7,85,0,17,103,95,0,17,0,8,28,35,95,0,7,0,9,57,12,85,0,7,85,0,17,85,0,-60,0,};
-		pcre* matchUri = (pcre*) _matchUri;
+		// static const char _matchUri[240]={69,82,67,80,-16,0,0,0,16,0,0,0,1,0,0,0,9,0,0,0,0,0,0,0,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,94,0,-60,26,103,95,0,49,0,1,95, 0,39,0,2,79,-1,-1,-1,-1,-9,127,-1,123,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,72,85,0,39,28,58,85,0,49,103,95,0,51,0,3,28,47,28,47,95,0,39,0,4,79,-1,-1,-1,-1,-9,127,-1,127,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,70,85,0,39,85,0,51,95,0,39,0,5,79,-1,-1,-1,-1,-9,-1,-1,127,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,70,85,0,39,103,95,0,17,0,6,28,63,95,0,7,0,7,44,35,85,0,7,85,0,17,103,95,0,17,0,8,28,35,95,0,7,0,9,57,12,85,0,7,85,0,17,85,0,-60,0,};
+		pcre* matchUri = getCompiledRegexp(REGEXP_URI);
 
 
 		int uriMatches[regExpMatchesVectorLength];
Index: COLLADAFramework/include/COLLADAFWSkinControllerData.h
===================================================================
--- COLLADAFramework/include/COLLADAFWSkinControllerData.h	(revision 571)
+++ COLLADAFramework/include/COLLADAFWSkinControllerData.h	(working copy)
@@ -58,7 +58,7 @@
 
 		/** Indices of joints assigned to a joint/vertex pair. The number of pairs for the i'th vertex is 
 		given by the i'th value in mJointsPerVertex.*/
-		UIntValuesArray mJointIndices;
+		IntValuesArray mJointIndices;
 
 	public:
 
@@ -121,8 +121,8 @@
 
 		/** Returns the indices of joints assigned to a joint/vertex pair. The number of pairs for the i'th vertex is 
 		given by the i'th value in mJointsPerVertex.*/
-		const COLLADAFW::UIntValuesArray& getJointIndices() const { return mJointIndices; }
-		COLLADAFW::UIntValuesArray& getJointIndices() { return mJointIndices; }
+		const COLLADAFW::IntValuesArray& getJointIndices() const { return mJointIndices; }
+		COLLADAFW::IntValuesArray& getJointIndices() { return mJointIndices; }
 
 	private:
 
Index: COLLADAFramework/src/COLLADAFWValidate.cpp
===================================================================
--- COLLADAFramework/src/COLLADAFWValidate.cpp	(revision 571)
+++ COLLADAFramework/src/COLLADAFWValidate.cpp	(working copy)
@@ -130,14 +130,14 @@
 		}
 
 		// test joint indices
-		const UIntValuesArray& jointIndices = skinControllerData->getJointIndices();
+		const IntValuesArray& jointIndices = skinControllerData->getJointIndices();
 
 		if ( jointsVertexPairCount != jointIndices.getCount() )
 			return false;
 
 		for ( size_t i = 0, count = jointIndices.getCount(); i < count; ++i)
 		{
-			if ( jointIndices[i] >= jointsCount)
+			if ( jointIndices[i] >= (int)jointsCount)
 				return false;
 		}
 		return true;
